{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#|default_exp test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#|export\n",
    "from fastcore.imports import *\n",
    "from collections import Counter\n",
    "from contextlib import redirect_stdout"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#|hide\n",
    "from nbdev.showdoc import *\n",
    "from fastcore.nb_imports import *"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Test\n",
    "\n",
    "> Helper functions to quickly write tests in notebooks"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Simple test functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can check that code raises an exception when that's expected (`test_fail`).\n",
    "\n",
    "To test for equality or inequality (with different types of things) we define a simple function `test` that compares two objects with a given `cmp` operator."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#|export\n",
    "def test_fail(f, msg='', contains='', args=None, kwargs=None):\n",
    "    \"Fails with `msg` unless `f()` raises an exception and (optionally) has `contains` in `e.args`\"\n",
    "    args, kwargs = args or [], kwargs or {}\n",
    "    try: f(*args, **kwargs)\n",
    "    except Exception as e:\n",
    "        assert not contains or contains in str(e)\n",
    "        return\n",
    "    assert False,f\"Expected exception but none raised. {msg}\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def _fail(): raise Exception(\"foobar\")\n",
    "test_fail(_fail, contains=\"foo\")\n",
    "\n",
    "def _fail(): raise Exception()\n",
    "test_fail(_fail)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also pass `args` and `kwargs` to function to check if it fails with special inputs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def _fail_args(a):\n",
    "    if a == 5:\n",
    "        raise ValueError\n",
    "test_fail(_fail_args, args=(5,))\n",
    "test_fail(_fail_args, kwargs=dict(a=5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#|export\n",
    "def test(a, b, cmp, cname=None):\n",
    "    \"`assert` that `cmp(a,b)`; display inputs and `cname or cmp.__name__` if it fails\"\n",
    "    if cname is None: cname=cmp.__name__\n",
    "    assert cmp(a,b),f\"{cname}:\\n{a}\\n{b}\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test([1,2],[1,2], operator.eq)\n",
    "test_fail(lambda: test([1,2],[1], operator.eq))\n",
    "test([1,2],[1],   operator.ne)\n",
    "test_fail(lambda: test([1,2],[1,2], operator.ne))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "---\n",
       "\n",
       "### all_equal\n",
       "\n",
       ">      all_equal (a, b)\n",
       "\n",
       "Compares whether `a` and `b` are the same length and have the same contents"
      ],
      "text/plain": [
       "---\n",
       "\n",
       "### all_equal\n",
       "\n",
       ">      all_equal (a, b)\n",
       "\n",
       "Compares whether `a` and `b` are the same length and have the same contents"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "show_doc(all_equal)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test(['abc'], ['abc'], all_equal)\n",
    "test_fail(lambda: test(['abc'],['cab'], all_equal))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "---\n",
       "\n",
       "### equals\n",
       "\n",
       ">      equals (a, b)\n",
       "\n",
       "Compares `a` and `b` for equality; supports sublists, tensors and arrays too"
      ],
      "text/plain": [
       "---\n",
       "\n",
       "### equals\n",
       "\n",
       ">      equals (a, b)\n",
       "\n",
       "Compares `a` and `b` for equality; supports sublists, tensors and arrays too"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "show_doc(equals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test([['abc'],['a']], [['abc'],['a']],  equals)\n",
    "test([['abc'],['a'],'b', [['x']]], [['abc'],['a'],'b', [['x']]],  equals) # supports any depth and nested structure"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#|export\n",
    "def nequals(a,b):\n",
    "    \"Compares `a` and `b` for `not equals`\"\n",
    "    return not equals(a,b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test(['abc'], ['ab' ], nequals)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## test_eq test_ne, etc..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Just use `test_eq`/`test_ne` to test for `==`/`!=`. `test_eq_type` checks things are equal and of the same type. We define them using `test`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#|export\n",
    "def test_eq(a,b):\n",
    "    \"`test` that `a==b`\"\n",
    "    test(a,b,equals, cname='==')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hide_input": false
   },
   "outputs": [],
   "source": [
    "test_eq([1,2],[1,2])\n",
    "test_eq([1,2],map(int,[1,2]))\n",
    "test_eq(array([1,2]),array([1,2]))\n",
    "test_eq(array([1,2]),array([1,2]))\n",
    "test_eq([array([1,2]),3],[array([1,2]),3])\n",
    "test_eq(dict(a=1,b=2), dict(b=2,a=1))\n",
    "test_fail(lambda: test_eq([1,2], 1), contains=\"==\")\n",
    "test_fail(lambda: test_eq(None, np.array([1,2])), contains=\"==\")\n",
    "test_eq({'a', 'b', 'c'}, {'c', 'a', 'b'})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#|hide\n",
    "import pandas as pd\n",
    "import torch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df1 = pd.DataFrame(dict(a=[1,2],b=['a','b']))\n",
    "df2 = pd.DataFrame(dict(a=[1,2],b=['a','b']))\n",
    "df3 = pd.DataFrame(dict(a=[1,2],b=['a','c']))\n",
    "\n",
    "test_eq(df1,df2)\n",
    "test_eq(df1.a,df2.a)\n",
    "test_fail(lambda: test_eq(df1,df3), contains='==')\n",
    "class T(pd.Series): pass\n",
    "test_eq(df1.iloc[0], T(df2.iloc[0])) # works with subclasses"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_eq(torch.zeros(10), torch.zeros(10, dtype=torch.float64))\n",
    "test_eq(torch.zeros(10), torch.ones(10)-1)\n",
    "test_fail(lambda:test_eq(torch.zeros(10), torch.ones(1, 10)), contains='==')\n",
    "test_eq(torch.zeros(3), [0,0,0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#|export\n",
    "def test_eq_type(a,b):\n",
    "    \"`test` that `a==b` and are same type\"\n",
    "    test_eq(a,b)\n",
    "    test_eq(type(a),type(b))\n",
    "    if isinstance(a,(list,tuple)): test_eq(map(type,a),map(type,b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hide_input": false
   },
   "outputs": [],
   "source": [
    "test_eq_type(1,1)\n",
    "test_fail(lambda: test_eq_type(1,1.))\n",
    "test_eq_type([1,1],[1,1])\n",
    "test_fail(lambda: test_eq_type([1,1],(1,1)))\n",
    "test_fail(lambda: test_eq_type([1,1],[1,1.]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#|export\n",
    "def test_ne(a,b):\n",
    "    \"`test` that `a!=b`\"\n",
    "    test(a,b,nequals,'!=')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hide_input": false
   },
   "outputs": [],
   "source": [
    "test_ne([1,2],[1])\n",
    "test_ne([1,2],[1,3])\n",
    "test_ne(array([1,2]),array([1,1]))\n",
    "test_ne(array([1,2]),array([1,1]))\n",
    "test_ne([array([1,2]),3],[array([1,2])])\n",
    "test_ne([3,4],array([3]))\n",
    "test_ne([3,4],array([3,5]))\n",
    "test_ne(dict(a=1,b=2), ['a', 'b'])\n",
    "test_ne(['a', 'b'], dict(a=1,b=2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#|export\n",
    "def is_close(a,b,eps=1e-5):\n",
    "    \"Is `a` within `eps` of `b`\"\n",
    "    if hasattr(a, '__array__') or hasattr(b,'__array__'):\n",
    "        return (abs(a-b)<eps).all()\n",
    "    if isinstance(a, (Iterable,Generator)) or isinstance(b, (Iterable,Generator)):\n",
    "        return all(abs(a_-b_)<eps for a_,b_ in zip(a,b))\n",
    "    return abs(a-b)<eps"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#|export\n",
    "def test_close(a,b,eps=1e-5):\n",
    "    \"`test` that `a` is within `eps` of `b`\"\n",
    "    test(a,b,partial(is_close,eps=eps),'close')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_close(1,1.001,eps=1e-2)\n",
    "test_fail(lambda: test_close(1,1.001))\n",
    "test_close([-0.001,1.001], [0.,1.], eps=1e-2)\n",
    "test_close(np.array([-0.001,1.001]), np.array([0.,1.]), eps=1e-2)\n",
    "test_close(array([-0.001,1.001]), array([0.,1.]), eps=1e-2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#|export\n",
    "def test_is(a,b):\n",
    "    \"`test` that `a is b`\"\n",
    "    test(a,b,operator.is_, 'is')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_fail(lambda: test_is([1], [1]))\n",
    "a = [1]\n",
    "test_is(a, a)\n",
    "b = [2]; test_fail(lambda: test_is(a, b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#|export\n",
    "def test_shuffled(a,b):\n",
    "    \"`test` that `a` and `b` are shuffled versions of the same sequence of items\"\n",
    "    test_ne(a, b)\n",
    "    test_eq(Counter(a), Counter(b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = list(range(50))\n",
    "b = copy(a)\n",
    "random.shuffle(b)\n",
    "test_shuffled(a,b)\n",
    "test_fail(lambda:test_shuffled(a,a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 'abc'\n",
    "b = 'abcabc'\n",
    "test_fail(lambda:test_shuffled(a,b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = ['a', 42, True] \n",
    "b = [42, True, 'a']\n",
    "test_shuffled(a,b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#|export\n",
    "def test_stdout(f, exp, regex=False):\n",
    "    \"Test that `f` prints `exp` to stdout, optionally checking as `regex`\"\n",
    "    s = io.StringIO()\n",
    "    with redirect_stdout(s): f()\n",
    "    if regex: assert re.search(exp, s.getvalue()) is not None, f\"regex '{exp}' did not not match stdout '{s.getvalue()}'\"\n",
    "    else: test_eq(s.getvalue(), f'{exp}\\n' if len(exp) > 0 else '')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_stdout(lambda: print('hi'), 'hi')\n",
    "test_fail(lambda: test_stdout(lambda: print('hi'), 'ho'))\n",
    "test_stdout(lambda: 1+1, '')\n",
    "test_stdout(lambda: print('hi there!'), r'^hi.*!$', regex=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#|export\n",
    "def test_warns(f, show=False):\n",
    "    with warnings.catch_warnings(record=True) as w:\n",
    "        f()\n",
    "        assert w, \"No warnings raised\"\n",
    "        if show:\n",
    "            for e in w: print(f\"{e.category}: {e.message}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_warns(lambda: warnings.warn(\"Oh no!\"))\n",
    "test_fail(lambda: test_warns(lambda: 2+2), contains='No warnings raised')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'UserWarning'>: Oh no!\n"
     ]
    }
   ],
   "source": [
    "test_warns(lambda: warnings.warn(\"Oh no!\"), show=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#|export\n",
    "TEST_IMAGE = 'images/puppy.jpg'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<PIL.Image.Image image mode=RGB size=128x128>"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "im = Image.open(TEST_IMAGE).resize((128,128)); im"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#|export\n",
    "TEST_IMAGE_BW = 'images/mnist3.png'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<PIL.Image.Image image mode=L size=128x128>"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "im = Image.open(TEST_IMAGE_BW).resize((128,128)); im"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#|export\n",
    "def test_fig_exists(ax):\n",
    "    \"Test there is a figure displayed in `ax`\"\n",
    "    assert ax and len(ax.figure.canvas.tostring_argb())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig,ax = plt.subplots()\n",
    "ax.imshow(array(im));"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_fig_exists(ax)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#|export\n",
    "class ExceptionExpected:\n",
    "    \"Context manager that tests if an exception is raised\"\n",
    "    def __init__(self, ex=Exception, regex=''): self.ex,self.regex = ex,regex\n",
    "    def __enter__(self): pass\n",
    "    def __exit__(self, type, value, traceback):\n",
    "        if not isinstance(value, self.ex) or (self.regex and not re.search(self.regex, f'{value.args}')):\n",
    "            raise TypeError(f\"Expected {self.ex.__name__}({self.regex}) not raised.\")\n",
    "        return True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def _tst_1(): assert False, \"This is a test\"\n",
    "def _tst_2(): raise SyntaxError\n",
    "\n",
    "with ExceptionExpected(): _tst_1()\n",
    "with ExceptionExpected(ex=AssertionError, regex=\"This is a test\"): _tst_1()\n",
    "with ExceptionExpected(ex=SyntaxError): _tst_2()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`exception` is an abbreviation for `ExceptionExpected()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#|export\n",
    "exception = ExceptionExpected()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with exception: _tst_1()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#|hide\n",
    "def _f():\n",
    "    with ExceptionExpected(): 1\n",
    "test_fail(partial(_f))\n",
    "\n",
    "def _f():\n",
    "    with ExceptionExpected(SyntaxError): assert False\n",
    "test_fail(partial(_f))\n",
    "\n",
    "def _f():\n",
    "    with ExceptionExpected(AssertionError, \"Yes\"): assert False, \"No\"\n",
    "test_fail(partial(_f))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Export -"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Converted 00_test.ipynb.\n",
      "Converted 01_basics.ipynb.\n",
      "Converted 02_foundation.ipynb.\n",
      "Converted 03_xtras.ipynb.\n",
      "Converted 03a_parallel.ipynb.\n",
      "Converted 03b_net.ipynb.\n",
      "Converted 04_dispatch.ipynb.\n",
      "Converted 05_transform.ipynb.\n",
      "Converted 07_meta.ipynb.\n",
      "Converted 08_script.ipynb.\n",
      "Converted index.ipynb.\n"
     ]
    }
   ],
   "source": [
    "#|hide\n",
    "#|eval: false\n",
    "from nbdev import nbdev_export\n",
    "nbdev_export()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "jupytext": {
   "split_at_heading": true
  },
  "kernelspec": {
   "display_name": "python3",
   "language": "python",
   "name": "python3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
